6.1 組合的语法

就以前的学习情况来看，事实上已进行了多次“组合”操作。为进行组合，我们只需在新类里简单地置入对象引用即可。举个例子来说，假定需要在一个对象里容纳几个String对象、两种基本数据类型以及属于另一个类的一个对象。对于非基本类型的对象来说，只需将引用置于新类即可；而对于基本数据类型来说，则需在自己的类中定义它们。如下所示（若执行该程序时有麻烦，请参见第3章3.1.2小节“赋值”）：

  1. //: SprinklerSystem.java
  2. // Composition for code reuse
  3. package c06;
  5. class WaterSource {
  6.   private String s;
  7.   WaterSource() {
  8.     System.out.println("WaterSource()");
  9.     s = new String("Constructed");
  10.   }
  11.   public String toString() { return s; }
  12. }
  14. public class SprinklerSystem {
  15.   private String valve1, valve2, valve3, valve4;
  16.   WaterSource source;
  17.   int i;
  18.   float f;
  19.   void print() {
  20.     System.out.println("valve1 = " + valve1);
  21.     System.out.println("valve2 = " + valve2);
  22.     System.out.println("valve3 = " + valve3);
  23.     System.out.println("valve4 = " + valve4);
  24.     System.out.println("i = " + i);
  25.     System.out.println("f = " + f);
  26.     System.out.println("source = " + source);
  27.   }
  28.   public static void main(String[] args) {
  29.     SprinklerSystem x = new SprinklerSystem();
  30.     x.print();
  31.   }
  32. } ///:~

WaterSource内定义的一个方法是比较特别的：toString()。大家不久就会知道，每种非基本类型的对象都有一个toString()方法。若编译器本来希望一个String，但却获得某个这样的对象，就会调用这个方法。所以在下面这个表达式中：

  1. System.out.println("source = " + source) ;

编译器会发现我们试图向一个WaterSource添加一个String对象（source =）。这对它来说是不可接受的，因为我们只能将一个字符串“添加”到另一个字符串，所以它会说：“我要调用toString()，把source转换成字符串！”经这样处理后，它就能编译两个字符串，并将结果字符串传递给一个System.out.println()。每次随同自己创建的一个类允许这种行为的时候，都只需要写一个toString()方法。

如果不深究，可能会草率地认为编译器会为上述代码中的每个引用都自动构造对象（由于Java的安全和谨慎的形象）。例如，可能以为它会为WaterSource调用默认构造器，以便初始化source。打印语句的输出事实上是：

  1. valve1 = null
  2. valve2 = null
  3. valve3 = null
  4. valve4 = null
  5. i = 0
  6. f = 0.0
  7. source = null

在类内作为字段使用的基本数据会初始化成零，就象第2章指出的那样。但对象引用会初始化成null。而且假若试图为它们中的任何一个调用方法，就会产生一次“异常”。这种结果实际是相当好的（而且很有用），我们可在不丢弃一次异常的前提下，仍然把它们打印出来。

编译器并不只是为每个引用创建一个默认对象，因为那样会在许多情况下招致不必要的开销。如希望引用得到初始化，可在下面这些地方进行：

(1) 在对象定义的时候。这意味着它们在构造器调用之前肯定能得到初始化。

(2) 在那个类的构造器中。

(3) 紧靠在要求实际使用那个对象之前。这样做可减少不必要的开销——假如对象并不需要创建的话。

下面向大家展示了所有这三种方法：

  1. //: Bath.java
  2. // Constructor initialization with composition
  4. class Soap {
  5.   private String s;
  6.   Soap() {
  7.     System.out.println("Soap()");
  8.     s = new String("Constructed");
  9.   }
  10.   public String toString() { return s; }
  11. }
  13. public class Bath {
  14.   private String
  15.     // Initializing at point of definition:
  16.     s1 = new String("Happy"),
  17.     s2 = "Happy",
  18.     s3, s4;
  19.   Soap castille;
  20.   int i;
  21.   float toy;
  22.   Bath() {
  23.     System.out.println("Inside Bath()");
  24.     s3 = new String("Joy");
  25.     i = 47;
  26.     toy = 3.14f;
  27.     castille = new Soap();
  28.   }
  29.   void print() {
  30.     // Delayed initialization:
  31.     if(s4 == null)
  32.       s4 = new String("Joy");
  33.     System.out.println("s1 = " + s1);
  34.     System.out.println("s2 = " + s2);
  35.     System.out.println("s3 = " + s3);
  36.     System.out.println("s4 = " + s4);
  37.     System.out.println("i = " + i);
  38.     System.out.println("toy = " + toy);
  39.     System.out.println("castille = " + castille);
  40.   }
  41.   public static void main(String[] args) {
  42.     Bath b = new Bath();
  43.     b.print();
  44.   }
  45. } ///:~

请注意在Bath构造器中，在所有初始化开始之前执行了一个语句。如果不在定义时进行初始化，仍然不能保证能在将一条消息发给一个对象引用之前会执行任何初始化——除非出现不可避免的运行期异常。 下面是该程序的输出：

  1. Inside Bath()
  2. Soap()
  3. s1 = Happy
  4. s2 = Happy
  5. s3 = Joy
  6. s4 = Joy
  7. i = 47
  8. toy = 3.14
  9. castille = Constructed

调用print()时，它会填充s4，使所有字段在使用之前都获得正确的初始化。